var express = require('express');
var router = express.Router();
const sql = require("../sql/sql");//引入增删改查命令
const pro = require("../sql/pro");//引入数据集合

/* GET home page. */


//获取所有商品信息的接口路由
router.get('/', function(req, res, next) {
  //查询数据库数，返回前端
  sql.find(pro,{},{_id:0,__v:0}).then((data)=>{
    res.send({
      state:200,
      title:"请求成功",
      data
    })
  }).catch(()=>{
    res.send({
      state:201,
      title:"请求失败",
      data:"NOT DATA"
    })
  })
});

/**
* @apiGroup 商品信息
* @api {get} /api/pro 获取所有商品数据
* @apiVersion 0.0.0
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro
*/


//获取单个商品信息的接口路由
router.get('/onePro', function(req, res, next) {
  const {id} = req.query;
  if(!id) res.send({
    state:201,
    title:"请求失败",
    data:"NOT DATA"
})
  sql.find(pro,{proId:id},{_id:0,__v:0}).then((data)=>{
    res.send({
      state:200,
      title:"请求成功",
      data
    })
  }).catch(()=>{
    res.send({
      state:201,
      title:"请求失败",
      data:"NOT DATA"
    })
  })
});

/**
* @apiGroup 商品信息
* @api {get} /api/pro/onePro 获取单个商品详情数据
* @apiVersion 0.0.0
* @apiDescription 获取商品详情数据，需要发送商品id
* @apiParam {string} id 商品id
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/onePro
*/


//获取排序商品数据接口的路由
router.get('/sort',(req, res, next)=>{
  //接收要排序的字段和方向
  const obj = req.query;
  //查询排序之后的数据，返回前端
  sql.sort(pro,{},{},obj).then((data)=>{
    res.send({
      state:200,
      title:"请求成功",
      data
    })
  }).catch(()=>{
    res.send({
      state:201,
      title:"请求失败",
      data:"NOT DATA"
    })
  })
});

/**
* @apiGroup 商品信息
* @api {get} /api/pro/sort 获取排序商品数据
* @apiVersion 0.0.0
* @apiDescription 获取排序商品数据，需要发送排序字段和排序方向，需要手动在地址中拼接要排序的字段和排序方向（1或-1）
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/sort
*/



//获取指定分页商品数据接口的路由
router.get('/page',function(req, res, next){
  //解析跳转页面的时传来的数据并设置默认值
  let {index = 0,num = 10}=req.query;//这里的index是get获取的页码索引
  //请求分页数据，注意页面获取数据的类型，数据返回前端
  sql.page(pro,{},{},num*1,index*1).then((data)=>{
      res.send({
        state:200,
        title:"请求成功",
        data
      });
   }).catch(()=>{
      res.send({
        state:201,
        title:"请求失败",
        data:"NOT DATA"
    })
  })
});

/**
* @apiGroup 商品信息
* @api {get} /api/pro/page 获取指定分页的商品数据
* @apiVersion 0.0.0
* @apiDescription 获取指定分页的商品数据，需要发送页码和单页条数
* @apiParam {number} index=0 页码
* @apiParam {number} num=10 单页条数
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/page
*/


//获取搜索商品数据接口的路由
router.get('/search',(req, res, next)=>{
  //接收要搜索的关键字
  const obj = req.query;
  //创建正则，准备给find方法做模糊查询的条件使用
  let reg = new RegExp(obj.search);
  //调用查询方法，把数据返回前端
  sql.find(pro,{proName:reg},{_id:0,__v:0}).then((data)=>{
      res.send({
        state:200,
        title:"请求成功",
        data
      });
   }).catch(()=>{
      res.send({
        state:201,
        title:"请求失败",
        data:"NOT DATA"
    })
  })
});

/**
* @apiGroup 商品信息
* @api {get} /api/pro/search 根据指定关键字搜索商品名称
* @apiVersion 0.0.0
* @apiDescription 根据指定关键字搜索商品名称，需要发送搜索关键字
* @apiParam {String} search 要搜索的关键字
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/search
*/


// 获取商品个数接口的路由
router.get('/count',(req, res, next)=>{
  // 发送查询命令，把数据返回前端
  sql.count(pro).then((data)=>{
      res.send({
          state:200,
          title:"请求成功",
          data
      })
  }).catch(()=>{
    res.send({
      state:201,
      title:"请求失败",
      data:"NOT DATA"
    })
  })
})

/**
* @apiGroup 商品信息
* @api {get} /api/pro/count  获取数据总条数
* @apiVersion 0.0.0
* @apiDescription 获取数据总条数
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/count
*/


//获取商品分类接口的路由
router.get('/column',(req, res, next)=>{
  sql.distinct(pro,"column").then((data)=>{
      res.send({
          state:200,
          title:"请求成功",
          data
      })
  }).catch(()=>{
    res.send({
      state:201,
      title:"请求失败",
      data:"NOT DATA"
    })
  })
})

/**
* @apiGroup 商品信息
* @api {get} /api/pro/column  获取商品分类
* @apiVersion 0.0.0
* @apiDescription 获取商品分类
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/column
*/

//获取商品分类接口的路由
router.get('/brand',(req, res, next)=>{
  let column = req.query.column;
  sql.find(pro,{column},{brand:1,logo:1,_id:0}).then((data)=>{
    let arr = norepeat(data)
    res.send({
        state:200,
        title:"请求成功",
        data:arr
    })
  }).catch(()=>{
    res.send({
      state:201,
      title:"请求失败",
      data:"NOT DATA"
    })
  })
})

/**
* @apiGroup 商品信息
* @api {get} /api/pro/column  根据商品分类获取品牌信息
* @apiVersion 0.0.0
* @apiDescription 获取商品分类
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/column
*/

// 判断数组中是否有重复数据的方法
//brr的形式[{},{},{}]
function indexOf(brr,b){
  let i = 0
  let onoff = brr.some((val,index)=>{
    i = index
    return val.brand === b
  })
  if(onoff){
    return i
  }else{
    return -1
  }
}
// 数组去重的方法
function norepeat(brr){
  let arr= []
  for(var i=0;i<brr.length;i++){
    if(indexOf(arr,brr[i].brand) == -1){
      arr.push(brr[i])
    }
  }
  return arr
}

//根据商品分类和品牌获取商品信息的路由
router.get('/brandlist',(req, res, next)=>{
  let column = req.query.column;
  let brand = req.query.brand;
  sql.find(pro,{column,brand},{_id:0,__v:0}).then((data)=>{
    res.send({
        state:200,
        title:"请求成功",
        data
    })
  }).catch(()=>{
    res.send({
      state:201,
      title:"请求失败",
      data:"NOT DATA"
    })
  })
})

/**
* @apiGroup 商品信息
* @api {get} /api/pro/brandlist  根据商品分类和商品获取商品信息
* @apiVersion 0.0.0
* @apiDescription 根据商品分类和商品获取商品信息
* @apiParam {String} column 商品分类
* @apiParam {String} brand 商品品牌
* @apiSuccess {number} state 请求状态
* @apiSuccess {string} title 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
* {
*    "state":200,
*    "title":"请求成功",
*    "data":[{},{},...]
* }
* @apiError {number} state 请求状态
* @apiError {string} title 请求说明
* @apiError {string} data 请求数据
* @apiErrorExample {json} Error-Response:
* {
*    "code":201,
*    "title":"请求失败",
*    "data":"NOT DATA"
* }
* @apiSampleRequest http://localhost:3001/api/pro/brandlist
*/


module.exports = router;
